<!DOCTYPE html>
<meta charset=utf-8>
<title>Setting the start time of scroll animation</title>
<link rel="help" href="https://drafts.csswg.org/web-animations/#setting-the-start-time-of-an-animation">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="/web-animations/testcommon.js"></script>
<script src="testcommon.js"></script>
<style>
.scroller {
  overflow: auto;
  height: 200px;
  width: 100px;
  will-change: transform;
}

.contents {
  height: 1000px;
  width: 100%;
}
</style>
<body>
<div id="log"></div>
<script>
'use strict';

promise_test(async t => {
  const animation = createScrollLinkedAnimation(t);
  const scroller = animation.timeline.scrollSource;
  const maxScroll = scroller.scrollHeight - scroller.clientHeight;
  scroller.scrollTop = 0.2 * maxScroll;
  // Wait for new animation frame which allows the timeline to compute new
  // current time.
  await waitForNextFrame();

  // So long as a hold time is set, querying the current time will return
  // the hold time.

  // Since the start time is unresolved at this point, setting the current time
  // will set the hold time
  animation.currentTime = 300;
  assert_equals(animation.startTime, null, 'The start time stays unresolved');
  assert_times_equal(animation.currentTime, 300,
                    'The current time is calculated from the hold time');

  // If we set the start time, however, we should clear the hold time.
  animation.startTime = 0;
  assert_times_equal(animation.startTime, 0,
                    'The start time is set to the requested value');
  assert_times_equal(animation.currentTime, 200,
                    'The current time is calculated from the start time, not' +
                    ' the hold time');
  // Sanity check
  assert_equals(animation.playState, 'running',
                'Animation reports it is running after setting a resolved ' +
                'start time');
}, 'Setting the start time clears the hold time');

promise_test(async t => {
  const animation = createScrollLinkedAnimation(t);
  const scroller = animation.timeline.scrollSource;
  // Make the scroll timeline inactive.
  scroller.style.overflow = 'visible';
  // Wait for new animation frame which allows the timeline to compute new
  // current time.
  await waitForNextFrame();
  assert_equals(animation.timeline.currentTime, null,
                'Sanity check the timeline is inactive');

  // So long as a hold time is set, querying the current time will return
  // the hold time.

  // Since the start time is unresolved at this point, setting the current time
  // will set the hold time
  animation.currentTime = 300;
  assert_equals(animation.startTime, null, 'The start time stays unresolved');
  assert_times_equal(animation.currentTime, 300,
                    'The current time is calculated from the hold time');

  // If we set the start time, however, we should clear the hold time.
  animation.startTime = 0;
  assert_times_equal(animation.startTime, 0,
                    'The start time is set to the requested value');
  assert_equals(animation.currentTime, null,
                'The current time is calculated from the start time, not' +
                ' the hold time');
  // Sanity check
  assert_equals(animation.playState, 'running',
                'Animation reports it is running after setting a resolved ' +
                'start time');
}, 'Setting the start time clears the hold time when the timeline is inactive');

promise_test(async t => {
  const animation = createScrollLinkedAnimation(t);
  const scroller = animation.timeline.scrollSource;
  const maxScroll = scroller.scrollHeight - scroller.clientHeight;
  scroller.scrollTop = 0.2 * maxScroll;

  // Wait for new animation frame which allows the timeline to compute new
  // current time.
  await waitForNextFrame();

  // Set up a running animation (i.e. both start time and current time
  // are resolved).
  animation.startTime = 50;
  assert_equals(animation.playState, 'running');
  assert_times_equal(animation.startTime, 50,
                     'The start time is set to the requested value');
  assert_times_equal(animation.currentTime, 150,
                     'Current time is resolved for a running animation');

  // Clear start time
  animation.startTime = null;
  assert_equals(animation.startTime, null,
                'The start time is set to the requested value');
  assert_times_equal(animation.currentTime, 150,
                    'Hold time is set after start time is made unresolved');
  assert_equals(animation.playState, 'paused',
                'Animation reports it is paused after setting an unresolved'
                + ' start time');
}, 'Setting an unresolved start time sets the hold time');

promise_test(async t => {
  const animation = createScrollLinkedAnimation(t);
  const scroller = animation.timeline.scrollSource;
  // Make the scroll timeline inactive.
  scroller.style.overflow = 'visible';
  // Wait for new animation frame which allows the timeline to compute new
  // current time.
  await waitForNextFrame();
  assert_equals(animation.timeline.currentTime, null,
                'Sanity check the timeline is inactive');

  // Set up a running animation (i.e. both start time and current time
  // are resolved).
  animation.startTime = 50;
  assert_equals(animation.playState, 'running');
  assert_times_equal(animation.startTime, 50,
                     'The start time is set to the requested value');
  assert_equals(animation.currentTime, null,
                'Current time is unresolved for a running animation when the ' +
                'timeline is inactive');

  // Clear start time
  animation.startTime = null;
  assert_equals(animation.startTime, null,
                'The start time is set to the requested value');
  assert_equals(animation.currentTime, null,
                'Hold time is set to unresolved after start time is made ' +
                'unresolved');
  assert_equals(animation.playState, 'idle',
                'Animation reports it is idle after setting an unresolved'
                + ' start time');
}, 'Setting an unresolved start time sets the hold time to unresolved when ' +
   'the timeline is inactive');

promise_test(async t => {
  const animation = createScrollLinkedAnimation(t);

  // Wait for new animation frame which allows the timeline to compute new
  // current time.
  await waitForNextFrame();

  let readyPromiseCallbackCalled = false;
  animation.ready.then(() => { readyPromiseCallbackCalled = true; } );

  // Put the animation in the play-pending state
  animation.play();

  // Sanity check
  assert_true(animation.pending && animation.playState === 'running',
              'Animation is in play-pending state');

  // Setting the start time should resolve the 'ready' promise, i.e.
  // it should schedule a microtask to run the promise callbacks.
  animation.startTime = 100;
  assert_times_equal(animation.startTime, 100,
                     'The start time is set to the requested value');
  assert_false(readyPromiseCallbackCalled,
               'Ready promise callback is not called synchronously');

  // If we schedule another microtask then it should run immediately after
  // the ready promise resolution microtask.
  await Promise.resolve();
  assert_true(readyPromiseCallbackCalled,
              'Ready promise callback called after setting startTime');
}, 'Setting the start time resolves a pending ready promise');

promise_test(async t => {
  const animation = createScrollLinkedAnimation(t);
  const scroller = animation.timeline.scrollSource;
  // Make the scroll timeline inactive.
  scroller.style.overflow = 'visible';
  // Wait for new animation frame which allows the timeline to compute new
  // current time.
  await waitForNextFrame();
  assert_equals(animation.timeline.currentTime, null,
                'Sanity check the timeline is inactive');

  let readyPromiseCallbackCalled = false;
  animation.ready.then(() => { readyPromiseCallbackCalled = true; } );

  // Put the animation in the play-pending state
  animation.play();

  // Sanity check
  assert_true(animation.pending && animation.playState === 'running',
              'Animation is in play-pending state');

  // Setting the start time should resolve the 'ready' promise, i.e.
  // it should schedule a microtask to run the promise callbacks.
  animation.startTime = 100;
  assert_times_equal(animation.startTime, 100,
                     'The start time is set to the requested value');
  assert_false(readyPromiseCallbackCalled,
               'Ready promise callback is not called synchronously');

  // If we schedule another microtask then it should run immediately after
  // the ready promise resolution microtask.
  await Promise.resolve();
  assert_true(readyPromiseCallbackCalled,
              'Ready promise callback called after setting startTime');
}, 'Setting the start time resolves a pending ready promise when the timeline' +
   'is inactive');

promise_test(async t => {
  const animation = createScrollLinkedAnimation(t);

  // Wait for new animation frame which allows the timeline to compute new
  // current time.
  await waitForNextFrame();

  // Put the animation in the play-pending state
  animation.play();

  // Sanity check
  assert_true(animation.pending, 'Animation is pending');
  assert_equals(animation.playState, 'running', 'Animation is play-pending');
  assert_times_equal(animation.startTime, 0, 'Start time is zero');

  // Setting start time should cancel the pending task.
  animation.startTime = null;
  assert_false(animation.pending, 'Animation is no longer pending');
  assert_equals(animation.playState, 'paused', 'Animation is paused');
}, 'Setting an unresolved start time on a play-pending animation makes it'
   + ' paused');

promise_test(async t => {
  const animation = createScrollLinkedAnimation(t);
  const scroller = animation.timeline.scrollSource;
  // Make the scroll timeline inactive.
  scroller.style.overflow = 'visible';
  // Wait for new animation frame which allows the timeline to compute new
  // current time.
  await waitForNextFrame();
  assert_equals(animation.timeline.currentTime, null,
                'Sanity check the timeline is inactive');

  // Put the animation in the play-pending state
  animation.play();

  // Sanity check
  assert_true(animation.pending, 'Animation is pending');
  assert_equals(animation.playState, 'running', 'Animation is play-pending');
  assert_times_equal(animation.startTime, 0, 'Start time is zero');

  // Setting start time should cancel the pending task.
  animation.startTime = null;
  assert_false(animation.pending, 'Animation is no longer pending');
  assert_equals(animation.playState, 'idle', 'Animation is idle');
}, 'Setting an unresolved start time on a play-pending animation makes it'
   + ' idle when the timeline is inactive');

promise_test(async t => {
  const animation = createScrollLinkedAnimation(t);
  // Wait for new animation frame which allows the timeline to compute new
  // current time.
  await waitForNextFrame();

  // Set start time such that the current time is past the end time
  animation.startTime = -1100;
  assert_times_equal(animation.startTime, -1100,
                     'The start time is set to the requested value');
  assert_equals(animation.playState, 'finished',
                'Seeked to finished state using the startTime');

  // If the 'did seek' flag is true, the current time should be greater than
  // the effect end.
  assert_greater_than(animation.currentTime,
                      animation.effect.getComputedTiming().endTime,
                      'Setting the start time updated the finished state with'
                      + ' the \'did seek\' flag set to true');

  // Furthermore, that time should persist if we have correctly updated
  // the hold time
  const finishedCurrentTime = animation.currentTime;
  await waitForNextFrame();
  assert_equals(animation.currentTime, finishedCurrentTime,
                'Current time does not change after seeking past the effect'
                + ' end time by setting the current time');
}, 'Setting the start time updates the finished state');

promise_test(async t => {
  const animation = createScrollLinkedAnimation(t);
  // Wait for new animation frame which allows the timeline to compute new
  // current time.
  await waitForNextFrame();
  animation.play();

  await animation.ready;
  assert_equals(animation.playState, 'running');

  // Setting the start time updates the finished state. The hold time is not
  // constrained by the effect end time.
  animation.startTime = -1100;
  assert_equals(animation.playState, 'finished');

  assert_times_equal(animation.currentTime, 1100);
}, 'Setting the start time on a running animation updates the play state');

promise_test(async t => {
  const animation = createScrollLinkedAnimation(t);
  // Wait for new animation frame which allows the timeline to compute new
  // current time.
  await waitForNextFrame();
  animation.play();
  await animation.ready;

  // Setting the start time updates the finished state. The hold time is not
  // constrained by the normal range of the animation time.
  animation.currentTime = 1000;
  assert_equals(animation.playState, 'finished', 'Animation is finished');
  animation.playbackRate = -1;
  assert_equals(animation.playState, 'running', 'Animation is running');
  animation.startTime = -2000;
  assert_equals(animation.playState, 'finished', 'Animation is finished');
  assert_times_equal(animation.currentTime, -2000);
}, 'Setting the start time on a reverse running animation updates the play '
   + 'state');
   promise_test(async t => {
  const animation = createScrollLinkedAnimation(t);
  // Wait for new animation frame which allows the timeline to compute new
  // current time.
  await waitForNextFrame();
  let readyPromiseCallbackCalled = false;
  animation.ready.then(() => { readyPromiseCallbackCalled = true; } );
  animation.pause();

  // Sanity check
  assert_true(animation.pending && animation.playState === 'paused',
              'Animation is in pause-pending state');

  // Setting the start time should resolve the 'ready' promise although
  // the resolution callbacks when be run in a separate microtask.
  animation.startTime = null;
  assert_false(readyPromiseCallbackCalled,
               'Ready promise callback is not called synchronously');

  await Promise.resolve();
  assert_true(readyPromiseCallbackCalled,
              'Ready promise callback called after setting startTime');
}, 'Setting the start time resolves a pending pause task');

promise_test(async t => {
  const anim = createScrollLinkedAnimation(t);
  // Wait for new animation frame which allows the timeline to compute new
  // current time.
  await waitForNextFrame();
  anim.play();

  // We should be play-pending now
  assert_true(anim.pending);
  assert_equals(anim.playState, 'running');

  // Apply a pending playback rate
  anim.updatePlaybackRate(2);
  assert_equals(anim.playbackRate, 1);
  assert_true(anim.pending);

  // Setting the start time should apply the pending playback rate
  anim.startTime = anim.timeline.currentTime - 25 * MS_PER_SEC;
  assert_equals(anim.playbackRate, 2);
  assert_false(anim.pending);

  // Sanity check that the start time is preserved and current time is
  // calculated using the new playback rate
  assert_times_equal(anim.startTime,
                     anim.timeline.currentTime - 25 * MS_PER_SEC);
  assert_time_equals_literal(anim.currentTime, 50 * MS_PER_SEC);
}, 'Setting the start time of a play-pending animation applies a pending playback rate');

promise_test(async t => {
  const anim = createScrollLinkedAnimation(t);
  // Wait for new animation frame which allows the timeline to compute new
  // current time.
  await waitForNextFrame();
  anim.play();
  await anim.ready;

  // We should be running now
  assert_false(anim.pending);
  assert_equals(anim.playState, 'running');

  // Apply a pending playback rate
  anim.updatePlaybackRate(2);
  assert_equals(anim.playbackRate, 1);
  assert_true(anim.pending);

  // Setting the start time should apply the pending playback rate
  anim.startTime = anim.timeline.currentTime - 250;
  assert_equals(anim.playbackRate, 2);
  assert_false(anim.pending);

  // Sanity check that the start time is preserved and current time is
  // calculated using the new playback rate
  assert_times_equal(anim.startTime,
                     anim.timeline.currentTime - 250);
  assert_time_equals_literal(parseInt(anim.currentTime.toPrecision(5), 10), 500);
}, 'Setting the start time of a playing animation applies a pending playback rate');
</script>
</body>
